#include<iostream>
#include<thread>
#include<vector>
#include<string>
#include<list>
#include<mutex>

// **********************Code5************************



// **********************Code4************************

// void work1(int& sum, std::mutex& mylock) {
// 	for (int i = 1; i < 5000; i++) {
// 		std::lock_guard<std::mutex> mylock_guard(mylock);
// 		sum += i;
// 	}
// }

// void work2(int& sum, std::mutex& mylock) {
// 	for (int i = 5000; i <= 10000; i++) {
// 		std::lock_guard<std::mutex> mylock_guard(mylock);
// 		sum += i;
// 	}
// }

// int fun() {
// 	int sum = 0;
// 	for (int i = 1; i <= 10000; i++) {
// 		sum += i;
// 	}
// 	return sum;
// }

// int main()
// {
// 	std::mutex mylock;
// 	int ans = 0;
// 	std::thread t1(work1, std::ref(ans), std::ref(mylock));
// 	std::thread t2(work2, std::ref(ans), std::ref(mylock));
// 	t1.join();
// 	t2.join();
// 	std::cout << "sum1 : " << ans << std::endl;
// 	std::cout << "sum2 : " << fun() << std::endl;
// 	return 0;
// }


// **********************Code2************************

// const std::vector<int> nums = {1, 2, 3};

// void threadEntry(int id) {
//     std::cout<< "thread start , id = " << id <<std::endl;
//     for (size_t i (0); i < nums.size(); i++){
//         std::cout<<nums[i]<< ", ";
//     }
//     std::cout<<std::endl;
//     std::cout<< "thread end , id = " << id <<std::endl;
// }

// int main() {
//     std::vector<std::thread> myThreads;
//     for (size_t i(0); i < 3; i++) {
//         myThreads.push_back(std::thread(threadEntry, i));
//     }
//     //for (auto it = myThreads.begin(); it != myThreads.end(); it++) it->join();
//     for (auto& it: myThreads) it.join();
//     std::cout<< "I Love China"<<std::endl;
//     return 0;
// }
// **********************Code3************************
// class Obj {
// public:
//     int val;
//     void threadFunc (){
//         std::cout<<"[Obj类]---线程执行"<< "线程ID = "<<std::this_thread::get_id()<<std::endl;
//     }

//     Obj(int _val): val(_val) {
//         std::cout<<"[构造]"<<" 线程ID = "<<std::this_thread::get_id()<<std::endl;
//     }

//     Obj(const Obj & T): val(T.val){
//         std::cout<<"[拷贝构造]"<<" 线程ID = "<<std::this_thread::get_id()<<std::endl;
//     }

//     ~Obj() {
//         std::cout<<"[析构]"<<" 线程ID = "<<std::this_thread::get_id()<<std::endl;
//     }

// };


// int main() {
//     int temp = 101;
//     std::cout<<"主线程ID = "<<std::this_thread::get_id()<<std::endl;
//     Obj myobj(temp);   // 构造函数
//     std::thread thread_1(&Obj::threadFunc, myobj); // 取址

//     thread_1.join();

//     std::cout << "I Love China " << 3000 << " TIMES" <<std::endl;
    
//     return 0;
// }

// class Message {
// public:
//     Message(int len):maxLen(len) {}
//     // 存入消息
//     void pushMessage(const int& i);
//     // 读取消息
//     int popMessage();
//     // 加锁
//     void getLock() {messMetux.lock();}
//     // 解锁
//     void freeLock() {messMetux.unlock();}

// private:
//     const int maxLen;
//     std::mutex messMetux; //互斥量
//     std::list<int> messageList;
// };

// void Message::pushMessage(const int& i) {
//     if (messageList.size() >= maxLen) {
//         std::cout<< "Overflow!"<<std::endl;
//     }else {
//         messageList.push_back(i);
//     }
//     return;
// }

// int Message::popMessage() {
//     int mess = -1;
//     if (!messageList.empty()) {
//         mess = messageList.front();
//         messageList.pop_front();
//     }
//     return mess;
// }

// void pushThread(Message& m, const int& mLen) {
//     for (size_t i(0); i < mLen + 1000; i++){
//         m.getLock();
//         m.pushMessage(i);
//         m.freeLock();
//     }
//     return;
// }

// void popThread(Message& m, const int& mLen) {
//     for (size_t i(0); i < mLen + 1000; i++){
//         m.getLock();
//         int getmess = m.popMessage();
//         // do something...
//         std::cout<<"当前消息为："<< getmess <<std::endl;
//         m.freeLock();
//     }
//     return;
// }

// int main() {
//     const int messageMaxLen = 10000;
//     Message myMess(messageMaxLen);
//     std::thread myPushThread(pushThread, std::ref(myMess), messageMaxLen);
//     std::thread myPopThread(popThread, std::ref(myMess), messageMaxLen);
//     myPushThread.join();
//     myPopThread.join();
//     return 0;
// }